{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "import gym\n",
    "\n",
    "from src.environments.MultiEnv import MultiEnv\n",
    "\n",
    "from matplotlib import pyplot as plt\n",
    "from collections import deque\n",
    "\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Categorical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Actor(nn.Module):\n",
    "    \"\"\"Some Information about ActorCritic\"\"\"\n",
    "    def __init__(self, state_size, action_size):\n",
    "        super(Actor, self).__init__()\n",
    "\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Linear(state_size, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, action_size)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "    \n",
    "class Critic(nn.Module):\n",
    "    \"\"\"Some Information about ActorCritic\"\"\"\n",
    "    def __init__(self, state_size):\n",
    "        super(Critic, self).__init__()\n",
    "\n",
    "        self.model = nn.Sequential(\n",
    "            nn.Linear(state_size, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, 64),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(64, 1)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.model(x)\n",
    "\n",
    "class Memory:\n",
    "    def __init__(self):\n",
    "        self.log_probs = []\n",
    "        self.values = []\n",
    "        self.dones = []\n",
    "        self.rewards = []\n",
    "    \n",
    "    def add(self, log_prob, value, done, reward):\n",
    "        self.log_probs.append(log_prob)\n",
    "        self.values.append(value)\n",
    "        self.dones.append(done)\n",
    "        self.rewards.append(reward)\n",
    "    \n",
    "    def clear(self):\n",
    "        self.log_probs = []\n",
    "        self.values = []\n",
    "        self.dones = []\n",
    "        self.rewards = []\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.log_probs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def update(mem, next_state):\n",
    "    q_values = []\n",
    "\n",
    "    # Do not add this one as it's for the next state\n",
    "    running_reward = critic(torch.tensor(next_state).float().to(device)).squeeze(dim=1)\n",
    "\n",
    "    for reward, done in zip(reversed(mem.rewards), reversed(mem.dones)):\n",
    "        mask = torch.from_numpy(np.array(1 - done)).float().to(device)\n",
    "        reward = torch.from_numpy(np.array(reward)).float().to(device)\n",
    "\n",
    "        running_reward = (reward + gamma * running_reward) * mask\n",
    "        q_values.append(running_reward)\n",
    "\n",
    "    values = torch.stack(mem.values).squeeze(dim=2).to(device)\n",
    "    log_probs = torch.stack(mem.log_probs).to(device)\n",
    "    q_values = torch.stack(q_values).to(device)\n",
    "\n",
    "    advantage = q_values - values\n",
    "\n",
    "    critic_loss = torch.pow(advantage, 2).mean()\n",
    "    actor_loss = (-log_probs * advantage).sum(dim=0).mean()\n",
    "\n",
    "    critic_optim.zero_grad()\n",
    "    critic_loss.backward(retain_graph=True)\n",
    "    critic_optim.step()\n",
    "\n",
    "    actor_optim.zero_grad()\n",
    "    actor_loss.backward(retain_graph=True)\n",
    "    actor_optim.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "env_name = \"CartPole-v1\"\n",
    "env = gym.make(env_name)\n",
    "\n",
    "state_space = env.observation_space.shape[0]\n",
    "action_space = env.action_space.n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "win_condition = 200\n",
    "\n",
    "num_episodes = 500\n",
    "bootstrap_len = 5\n",
    "\n",
    "gamma = 0.99"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "mem = Memory()\n",
    "\n",
    "actor = Actor(state_space, action_space).to(device)\n",
    "critic = Critic(state_space).to(device)\n",
    "\n",
    "actor_optim = optim.Adam(actor.parameters(), lr=1e-3)\n",
    "critic_optim = optim.Adam(critic.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "env = MultiEnv(env_name, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ubuntu/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:14: UserWarning: Implicit dimension choice for softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Episode: 0.000\tAverage Score 14.000\tReward: 14.000\n",
      " Episode: 50.000\tAverage Score 11.333\tReward: 8.0000\n",
      " Episode: 100.000\tAverage Score 12.580\tReward: 14.000\n",
      " Episode: 150.000\tAverage Score 18.200\tReward: 30.000\n",
      " Episode: 200.000\tAverage Score 27.670\tReward: 31.000\n",
      " Episode: 250.000\tAverage Score 43.790\tReward: 93.0000\n",
      " Episode: 300.000\tAverage Score 150.790\tReward: 400.000\n",
      " Episode: 315.000\tAverage Score 204.470\tReward: 500.000Environment Solved!\n"
     ]
    }
   ],
   "source": [
    "score_log = []\n",
    "average_score_log = []\n",
    "running_scores = deque(maxlen=100)\n",
    "\n",
    "for i in range(num_episodes):\n",
    "    state = env.reset()\n",
    "    steps = 0\n",
    "    score = 0\n",
    "    \n",
    "    while True:\n",
    "        steps += 1\n",
    "\n",
    "        value = critic(torch.tensor(state).float().to(device))\n",
    "        logits = F.softmax(actor(torch.tensor(state).float().to(device)))\n",
    "\n",
    "        probabilities = Categorical(logits)\n",
    "        action = probabilities.sample()\n",
    "        log_probs = probabilities.log_prob(action)\n",
    "\n",
    "        next_state, reward, done, _ = env.step(action.cpu().numpy())\n",
    "        score += reward\n",
    "\n",
    "        mem.add(log_probs, value, done, reward)\n",
    "\n",
    "        if (done.any() or steps % bootstrap_len == 0):\n",
    "            update(mem, next_state)\n",
    "            mem.clear()\n",
    "        \n",
    "        if done.any():\n",
    "            break\n",
    "        \n",
    "        state = next_state\n",
    "\n",
    "    score_log.append(score[0])\n",
    "    running_scores.append(score[0])\n",
    "    average_score_log.append(np.mean(running_scores))\n",
    "    \n",
    "    print(\"\\r Episode: {:.3f}\\tAverage Score {:.3f}\\tReward: {:.3f}\".format(i, np.mean(running_scores), score[0]), end=\"\")\n",
    "    if (i % 50 == 0):\n",
    "        print(\"\\r Episode: {:.3f}\\tAverage Score {:.3f}\\tReward: {:.3f}\".format(i, np.mean(running_scores), score[0]))\n",
    "\n",
    "    if np.mean(running_scores) > win_condition:\n",
    "        print(\"Environment Solved!\")\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f1c265bc668>]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(score_log)\n",
    "plt.plot(average_score_log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
